home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / fzartmap.c < prev    next >
Text File  |  1993-08-23  |  7KB  |  337 lines
  1. /* fzartmap.c */
  2. /************************************************************************
  3.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  4.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  5.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  6.  *                                                                      *
  7.  * All rights reserved.  No part of this program may be reproduced,     *
  8.  * stored in a retrieval system, or transmitted, in any form or by any  *
  9.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  10.  * without the prior written permission of the copyright owner,         *
  11.  * NeuralWare, Inc.                                                     *
  12.  *                                                                      *
  13.  *                          PROPRIETARY NOTICE                          *
  14.  *                                                                      *
  15.  * This document is the property of NeuralWare, Inc. and contains       *
  16.  * trade-secrets and other proprietary information.  The information    *
  17.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  18.  * published, reproduced, copied, disclosed, used, or reverse           *
  19.  * engineered without the express written consent of a duly authorized  *
  20.  * representative of NeuralWare.                                        *
  21.  ************************************************************************
  22.  */
  23.  
  24.  
  25. #define UIO_SERVER             1
  26. #define SERVER_EMULATOR_FILE   1
  27. #define SKIP_COMPAT_DATA       1
  28. #include "userutl.h"
  29. #include "uio_strc.h"
  30. #include "uio_tran.h"
  31. #include "uio_reqs.pro"
  32. #include "uio_cmds.pro"
  33.  
  34. #include <math.h>
  35.  
  36. #ifdef MAC
  37. #include "macuio.redef"
  38. #endif
  39.  
  40. int W_Wid  = {200};  /* basic defining parameters */
  41. int W_Ht   = {200};  /* height of graph */
  42. int count = 0;
  43. int good_count = 0;
  44. float      xin, yin, desval;
  45. TEXT  sbuf[100];
  46. int   circ_color;
  47. int   back_color;
  48. int   on_color;
  49. int   off_color;
  50.  
  51. #define W0 1
  52. #define W1 2
  53. #define UPDT_INTERVAL 100
  54.  
  55.  
  56. NINT UIO_Init(file)
  57. TEXT *file;
  58. {
  59.   NINT ret_val = UIO_OK;
  60.   NINT xsize, ysize, ncolor, chrx, chry; /* graphics parameters */
  61.  
  62.   /* Get screen parameters */
  63.   ug_gparms( &xsize, &ysize, &ncolor, &chrx, &chry);
  64.   
  65.   if ( ncolor < 8 ) {
  66.     circ_color = 1;
  67.     back_color = 0;
  68.     on_color   = 1;
  69.     off_color  = 0;
  70.   } else {
  71.     circ_color = 1;
  72.     back_color = 0;
  73.     on_color   = 6;
  74.     off_color  = 5;
  75.   }
  76.  
  77.   /* Set up windows */
  78.   ug_window(W0, back_color, 20, 100, 20+W_Wid, 100+W_Ht);
  79.   ug_window(W1, back_color, 20, 75, 20+W_Wid, 99);
  80.  
  81.   return(ret_val);
  82. }
  83.  
  84.  
  85. NINT UIO_Term(process)
  86. NINT process;
  87. {
  88.   NINT ret_val = UIO_OK;
  89.  
  90.   return(ret_val);
  91. }
  92.  
  93. NINT UIO_Attention()
  94. {
  95.   NINT ret_val = UIO_OK;
  96.  
  97.   return(ret_val);
  98. }
  99.  
  100.  
  101. NINT UIO_Learn_Start()
  102. {
  103.   NINT ret_val = UIO_OK;
  104.  
  105.   /* Set up learn file */
  106.   ug_fileio("circ_trn", 0, 1, 1, 1);
  107.  
  108.   count = 0;
  109.  
  110.   return(ret_val);
  111. }
  112.  
  113. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  114. NINT  LayN;
  115. NINT  nPEs;
  116. SREAL *Datap;
  117. {
  118.   NINT ret_val = UIO_OK;
  119.  
  120.   return(ret_val);
  121. }
  122.  
  123. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  124. NINT  LayN;
  125. NINT  nPEs;
  126. SREAL *Datap;
  127. {
  128.   NINT ret_val = UIO_OK;
  129.  
  130.  
  131.   return(ret_val);
  132. }
  133.  
  134.  
  135. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  136. NINT  LayN;
  137. NINT  nPEs;
  138. SREAL *Datap;
  139. {
  140.    NINT  n_cn_vals;
  141.    SREAL cn_vals[10];
  142.    NINT  ret_val = UIO_OK;
  143.    NINT  wx;
  144.  
  145.    count++;
  146.  
  147.    if (count%UPDT_INTERVAL != 0)
  148.       return(ret_val);
  149.  
  150.    ug_winclr(W0);
  151.    ug_winclr(W1);
  152.    ug_circle(W0,circ_color,0,W_Wid/2,W_Ht/2, (4*W_Wid)/10,
  153.              circ_color==on_color?0:1);
  154.  
  155.    for (wx=0; wx<1000; wx++) {
  156.       APE   ape;
  157.  
  158.       /* Get PE information from category layer */
  159.       if (ug_peio(&ape, 0, 2, wx) != 0 ||
  160.           ape.ape_Flags&0x0001) break;
  161.  
  162.       n_cn_vals = 4;
  163.       ug_cnio(2,wx,1,0,&n_cn_vals,0,0,cn_vals);
  164.       ug_box(W0, on_color, 0,
  165.              (NINT)(cn_vals[0]*W_Wid),
  166.              (NINT)(cn_vals[1]*W_Ht),
  167.              (NINT)((1-cn_vals[2])*W_Wid),
  168.              (NINT)((1-cn_vals[3])*W_Ht),
  169.              0);
  170.    }
  171.   
  172.    /* Now display the category count */
  173.    sprintf(sbuf, "%ld ART Categories", (long)wx);
  174.    ug_puts(W1,on_color,0,15,4,sbuf,0);
  175.    return(ret_val);
  176. }
  177.  
  178. NINT UIO_Learn_End()
  179. {
  180.   NINT ret_val = UIO_OK;
  181.  
  182.  
  183.   PutStr("Hit <Enter> to continue:");
  184.   GetStr( );
  185.  
  186.   return(ret_val);
  187. }
  188.  
  189. NINT UIO_Recall_Start()
  190. {
  191.   NINT ret_val = UIO_OK;
  192.   TEXT *sp;
  193.  
  194.   PutStr("Test Set (T) or Training Set (L)?: ");
  195.   sp = GetStr( );
  196.   if (sp[0] == 'l' || sp[0] == 'L')
  197.      ug_fileio("circ_trn", 1, 0, 0, 0);
  198.   else
  199.      ug_fileio("circ_tst", 1, 0, 0, 0);
  200.  
  201.   ug_winclr(W0);
  202.   ug_winclr(W1);
  203.   ug_circle(W0,15,0,W_Wid/2,W_Ht/2, (4*W_Wid)/10,0);
  204.  
  205.   count = 0;
  206.   good_count = 0;
  207.  
  208.   return(ret_val);
  209. }
  210.  
  211.  
  212. NINT UIO_Read(LayN, nPEs, Datap)
  213. NINT  LayN;
  214. NINT  nPEs;
  215. SREAL *Datap;
  216. {
  217.   NINT ret_val = UIO_OK;
  218.  
  219.   /* Since this is file IO, the data should already be in the buffer */
  220.   xin = Datap[0];
  221.   yin = Datap[1];
  222.   desval = -1.0;
  223.   return(ret_val);
  224. }
  225.  
  226. NINT UIO_Write(LayN, nPEs, Datap)
  227. NINT  LayN;
  228. NINT  nPEs;
  229. SREAL *Datap;
  230. {
  231.   NINT  ret_val = UIO_OK;
  232.   SREAL outval;
  233.   NINT  x0, y0;
  234.  
  235.   outval = Datap[0];
  236.  
  237.   x0 = xin*W_Wid;
  238.   y0 = yin*W_Ht;
  239.   ug_box(W0, outval>0.5?on_color:off_color,0,
  240.          x0-1,y0-1,x0+1,y0+1,0);
  241.  
  242.   if (desval >-0.5) {
  243.      count ++;
  244.      if (fabs(desval-outval) < 0.1)
  245.         good_count++;
  246.   }
  247.  
  248.   return(ret_val);
  249. }
  250.  
  251. NINT UIO_Write_Step(LayN, nPEs, Datap)
  252. NINT  LayN;
  253. NINT  nPEs;
  254. SREAL *Datap;
  255. {
  256.   NINT ret_val = UIO_OK;
  257.  
  258.   return(ret_val);
  259. }
  260.  
  261.  
  262. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  263. NINT  LayN;
  264. NINT  nPEs;
  265. SREAL *Datap;
  266. {
  267.   NINT ret_val = UIO_OK;
  268.  
  269.   /* Since this is file IO, the data should already be in the buffer */
  270.   desval = Datap[0];
  271.  
  272.   return(ret_val);
  273. }
  274.  
  275. NINT UIO_Recall_End()
  276. {
  277.   NINT ret_val = UIO_OK;
  278.  
  279.   ug_circle(W0,15,0,W_Wid/2,W_Ht/2, (4*W_Wid)/10,0);
  280.  
  281.   if (count > 0) {
  282.      sprintf(sbuf,"%5.2f%% Correct",
  283.              100.0 * ( ((float)good_count) / ((float)count) ) );
  284.      ug_puts(W1,on_color,0,15,4,sbuf,0);
  285.   } else {
  286.      PutStr("If you want classification rate, run in Test Mode.\n");
  287.   }
  288.  
  289.  
  290.   PutStr("Hit <Enter> to continue:");
  291.   GetStr( );
  292.  
  293.   return(ret_val);
  294. }
  295.  
  296. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  297. NINT  Instrument_id;
  298. NINT  nDataElems;
  299. SREAL *DataElemp;
  300. {
  301.   NINT ret_val = UIO_OK;
  302.  
  303.   return(ret_val);
  304. }
  305.  
  306. /* FUNCTION */
  307. NINT UIO_ObjFunc(eoeflag, DataElemp)
  308. NINT  eoeflag;
  309. SREAL *DataElemp;
  310. {
  311.   NINT ret_val = UIO_OK;
  312.  
  313.   /* USER TO PLACE CODE HERE */
  314.  
  315.   return(ret_val);
  316. }
  317.  
  318. NINT UIO_Rewind()
  319. {
  320.   NINT ret_val = UIO_OK;
  321.  
  322.   return(ret_val);
  323. }
  324.  
  325. NINT UIO_Explain(LayN, nPEs, Datap)
  326. NINT  LayN;
  327. NINT  nPEs;
  328. SREAL *Datap;
  329. {
  330.   NINT ret_val = UIO_OK;
  331.  
  332.   return(ret_val);
  333. }
  334.  
  335.  
  336.  
  337.